+2005-09-01 Øyvind Kolås <pippin@gimp.org>
+
+ Added a 128 item hashtable to each object list.
+
+ * babl/Makefile.am: added new file 'babl-db.c'
+ * babl/babl-db.h: moved static function ...
+ * babl/babl-db.c: ... here in a new file, also implemented a hashing
+ optimization based on the strings of names.
+ * babl/babl-internal.h: changed API in base class templates.
+ * babl/babl-component.c,
+ * babl/babl-extension.c,
+ * babl/babl-fish.c,
+ * babl/babl-format.c,
+ * babl/babl-image.c,
+ * babl/babl-model.c,
+ * babl/babl-sampling.c,
+ * babl/babl-type.c: changed db_insert(..) to babl_db_insert(db, ...)
+
+ * babl/babl.c: added babl_fish_init ()
+
2005-08-31 Øyvind Kolås <pippin@gimp.org>
* docs/index-static.html.in: Changed ChangeLog link in NEWS section.
c_sources = \
babl.c \
babl-core.c \
+ babl-db.c \
babl-component.c \
babl-conversion.c \
babl-extension.c \
babl = component_new (first_arg, id, luma, chroma, alpha);
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
return ret;
planar, planar_bit);
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
return ret;
/* babl - dynamically extendable universal pixel conversion library.
- * Copyright (C) 2005, Øyvind Kolås.
- *
+
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
return n;
}
-
static long
copy_strip_1 (int src_bands,
void **src,
--- /dev/null
+/* babl - dynamically extendable universal pixel conversion library.
+ * Copyright (C) 2005, Øyvind Kolås.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#define _BABL_DB_C
+
+#include <string.h>
+#include "babl-internal.h"
+
+#define HASH_TABLE_SIZE 128
+#define DB_INITIAL_SIZE 16
+#define DB_INCREMENT_SIZE 16
+
+static inline int hash (const char *str)
+{
+ int ret = 0;
+ int i = 1;
+
+ while (*str)
+ ret = (ret + ( i++ * (*str ++ & 31 ))) % (HASH_TABLE_SIZE-1);
+ return ret;
+}
+
+typedef struct _BablDb {
+ Babl *hash [HASH_TABLE_SIZE];
+ int size;
+ int count;
+ Babl **items;
+} _BablDb;
+
+Babl *
+babl_db_find (BablDb *db,
+ const char *name)
+{
+ Babl *ret = babl_db_exist (db, 0, name);
+
+ if (!ret)
+ {
+ const char *sample_type = "unknwon";
+
+ if (db->items[0])
+ sample_type = babl_class_name (db->items[0]->class_type);
+ babl_log ("failed (query performed on a %s database)", sample_type);
+ }
+ return ret;
+}
+
+
+BablDb *
+babl_db_init(void)
+{
+ BablDb *db = babl_calloc (sizeof (BablDb), 1);
+ db->size = DB_INITIAL_SIZE;
+ db->count = 0;
+ db->items = NULL;
+ if (db->size)
+ {
+ db->items = babl_calloc (sizeof (BablInstance*), db->size);
+ }
+ return db;
+}
+
+void
+babl_db_destroy (BablDb *db)
+{
+ babl_free (db->items);
+ babl_free (db);
+}
+
+Babl *
+babl_db_insert (BablDb *db,
+ Babl *item)
+{
+ Babl *collision;
+
+ babl_assert (db && item);
+ babl_assert (item->instance.name);
+
+ collision = babl_db_exist (db, item->instance.id, item->instance.name);
+
+ if (collision)
+ return collision;
+
+ if (db->count + 1 > db->size) /* must reallocate storage */
+ {
+ Babl **new_items;
+
+ new_items = babl_realloc (db->items, (db->size + DB_INCREMENT_SIZE) * sizeof (BablInstance*));
+ babl_assert (new_items);
+
+ db->items = new_items;
+
+ /* null out the currently unused portions of memory */
+ memset (db->items + db->size, 0, DB_INCREMENT_SIZE * sizeof (Babl*));
+ db->size += DB_INCREMENT_SIZE;
+ }
+
+ {
+ int key = hash (item->instance.name);
+ if (db->hash[key] == NULL)
+ db->hash[key] = item;
+ }
+ db->items[db->count++]=item;
+
+ /* this point all registered items pass through, a nice
+ * place to brand them with where the item came from. */
+ item->instance.creator = babl_extender ();
+ return item;
+}
+
+void
+babl_db_each (BablDb *db,
+ BablEachFunction each_fun,
+ void *user_data)
+{
+ int i;
+
+ for (i=0; i< db->count; i++)
+ {
+ if (db->items[i])
+ {
+ if (each_fun ((Babl*) db->items[i], user_data))
+ break;
+ }
+ }
+}
+
+typedef struct BablDbExistData
+{
+ int id;
+ const char *name;
+ Babl *ret;
+} BablDbExistData;
+
+static int
+babl_db_each_exist (Babl *babl,
+ void *void_data)
+{
+ BablDbExistData *data = void_data;
+
+ if (data->id && data->id == babl->instance.id)
+ {
+ data->ret = babl;
+ return 1; /* stop iterating */
+ }
+ else if (data->name && !strcmp (babl->instance.name, data->name))
+ {
+ data->ret = babl;
+ return 1; /* stop iterating */
+ }
+ return 0; /* continue iterating */
+}
+
+Babl *
+babl_db_exist (BablDb *db,
+ int id,
+ const char *name)
+{
+ Babl *ret = NULL;
+
+ if (name)
+ ret = db->hash[hash (name)];
+ if (ret &&
+ name[0] == ret->instance.name[0] &&
+ !strcmp (name, ret->instance.name))
+ return ret;
+
+ {
+ BablDbExistData data;
+
+ data.id = id;
+ data.name = name;
+ data.ret = NULL;
+
+ babl_db_each (db, babl_db_each_exist, &data);
+
+ return data.ret;
+ }
+}
* Boston, MA 02111-1307, USA.
*/
-
#ifndef _DB_H
#define _DB_H
#error babl-db.h is only to be included after babl-internal.h
#endif
-#include <string.h>
-
-#define DB_DEF static inline
-
-#ifndef DB_INITIAL_SIZE
-#define DB_INITIAL_SIZE 16
-#endif
-#ifndef DB_INCREMENT_SIZE
-#define DB_INCREMENT_SIZE 16
-#endif
-
-static inline int hash (char *str)
-{
- int ret = 0;
- int i = 1;
-
- while (*str)
- ret = (ret + ( i++ * (*str ++ & 31 ))) % 199;
- return ret;
-}
-
-/* file scope variables, for this .c file's database */
-static int db_size = 0;
-static int db_entries = 0;
-static Babl **db;
+typedef struct _BablDb BablDb;
-DB_DEF void db_init (void);
-DB_DEF void db_destroy (void);
-DB_DEF void db_each (BablEachFunction each_fun,
+BablDb * babl_db_init (void);
+void babl_db_destroy (BablDb *db);
+void babl_db_each (BablDb *db,
+ BablEachFunction each_fun,
void *user_data);
-DB_DEF Babl * db_insert (Babl *entry);
-DB_DEF Babl * db_exist (int id,
- const char *name);
-
-DB_DEF Babl * db_find (const char *name)
-{
- Babl *ret = db_exist (0, name);
-
- if (!ret)
- {
- const char *sample_type = "unknwon";
-
- if (db[0])
- sample_type = babl_class_name (db[0]->class_type);
- babl_log ("failed (query performed on a %s database)", sample_type);
- }
- return ret;
-}
-
-
-DB_DEF void
-db_init(void)
-{
- if (0==db_size)
- {
- db_size = DB_INITIAL_SIZE;
- db = NULL;
- if (db_size)
- {
- db = babl_calloc (sizeof (BablInstance*), db_size);
- }
- }
-}
-
-
-DB_DEF void
-db_destroy (void)
-{
- babl_free (db);
- db_size = 0;
- db_entries = 0;
- db = NULL;
-}
-
-DB_DEF Babl *
-db_insert (Babl *babl)
-{
- Babl *collision;
-
- if (!babl)
- {
- babl_log ("%s(babl=%p)", __FUNCTION__, babl);
- return NULL;
- }
-
- collision = db_exist (babl->instance.id, babl->instance.name);
-
- if (collision)
- return collision;
-
- if (db_entries + 1 > db_size) /* must reallocate storage */
- {
- Babl **new_db;
-
- new_db = babl_realloc (db, (db_size + DB_INCREMENT_SIZE) * sizeof (BablInstance*));
- if (!new_db)
- {
- babl_log ("unable to reallocate memory, element (%i:'%s') not inserted",
- babl->instance.id, babl->instance.name);
- return NULL;
- }
- db = new_db;
-
- /* null out the currently unused portions of memory */
- memset (db + db_size, 0, DB_INCREMENT_SIZE * sizeof (Babl*));
- db_size += DB_INCREMENT_SIZE;
- }
- babl->instance.creator = babl_extender ();
- db[db_entries++]=babl;
- return babl;
-}
-
-
-DB_DEF void
-db_each (BablEachFunction each_fun,
- void *user_data)
-{
- int i;
-
- for (i=0; i< db_entries; i++)
- {
- if (db[i])
- {
- if (each_fun ((Babl*) db[i], user_data))
- break;
- }
- }
-}
-
-typedef struct BablDbExistData
-{
- unsigned int type;
- int id;
- const char *name;
- Babl *ret;
-} BablDbExistData;
-
-DB_DEF int
-db_each_exist (Babl *babl,
- void *void_data)
-{
- BablDbExistData *data = void_data;
-
- if (data->id && data->id == babl->instance.id)
- {
- data->ret = babl;
- return 1; /* stop iterating */
- }
- else if (data->name && !strcmp (babl->instance.name, data->name))
- {
- data->ret = babl;
- return 1; /* stop iterating */
- }
- return 0; /* continue iterating */
-}
-
-DB_DEF Babl *
-db_exist (int id,
- const char *name)
-{
- BablDbExistData data;
-
- data.id = id;
- data.name = name;
- data.ret = NULL;
-
- db_each (db_each_exist, &data);
-
- return data.ret;
-}
+Babl * babl_db_insert (BablDb *db,
+ Babl *entry);
+Babl * babl_db_exist (BablDb *db,
+ int id,
+ const char *name);
+Babl * babl_db_find (BablDb *db,
+ const char *name);
#endif
if (babl_quiet)
return babl_quiet;
babl_quiet = extension_new ("", NULL, NULL);
- db_insert (babl_quiet);
return babl_quiet;
}
void *dl_handle = NULL;
void (*destroy) (void) = NULL;
+ if (!db)
+ db = babl_db_init ();
babl = extension_new ("BablBase",
dl_handle,
destroy);
babl_set_extender (babl);
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
else
static void
destroy_hook (void)
{
+ babl_free (babl_quiet);
babl_quiet=NULL;
}
return load_failed (babl);
}
- if (db_insert (babl) == babl)
+ if (babl_db_insert (db, babl) == babl)
{
babl_set_extender (NULL);
return babl;
babl->fish.pixels = 0;
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
return ret;
component, sampling, type);
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
return ret;
BABL_TYPE_BASE = 100,
BABL_U8,
BABL_U16,
+ BABL_U32,
BABL_FLOAT,
BABL_DOUBLE,
BABL_HALF_FLOAT,
#include <unistd.h>
void
-babl_die (void)
+babl_backtrack (void)
{
char buf[512];
sprintf (buf,"echo bt>/tmp/babl.gdb;"
"gdb -q --batch -x /tmp/babl.gdb --pid=%i 2>/dev/null", getpid());
system (buf);
+}
+
+void
+babl_die (void)
+{
+ babl_backtrack ();
exit (-1);
}
#define _BABL_INTERNAL_H
+#include "babl-db.h"
#include "babl-ids.h"
#include "babl-util.h"
#include "babl-memory.h"
/**** LOGGER ****/
#include <stdarg.h>
+void babl_backtrack (void);
+
static inline void
real_babl_log (const char *file,
int line,
void babl_internal_init (void);
void babl_internal_destroy (void);
+extern BablDb *db;
#define BABL_DEFINE_EACH(type_name) \
void \
babl_##type_name##_each (BablEachFunction each_fun, \
- void *user_data) \
+ void *user_data) \
{ \
- db_each (each_fun, user_data); \
+ babl_db_each (db, each_fun, user_data); \
} \
#define BABL_DEFINE_LOOKUP_BY_ID(type_name) \
babl_##type_name##_id (int id) \
{ \
Babl *babl; \
- babl = db_exist (id, NULL); \
+ babl = babl_db_exist (db, id, NULL); \
if (!babl) \
{ \
- babl_log ("%s(%i): not found", __FUNCTION__, id); \
+ babl_log ("%s(%i): not found", __FUNCTION__, id); \
} \
return babl; \
}
{ \
babl_log ("%s(\"%s\"): hmpf!", __FUNCTION__, name); \
} \
- babl = db_exist (0, name); \
+ babl = babl_db_exist (db, 0, name); \
\
if (!babl) \
{ \
#endif
#define BABL_DEFINE_INIT(type_name) \
+ \
+static BablDb *db=NULL; \
+ \
void \
babl_##type_name##_init (void) \
{ \
BABL_PRE_INIT_HOOK; \
- db_init (); \
+ if (!db) \
+ db=babl_db_init (); \
BABL_INIT_HOOK; \
}
babl_##type_name##_destroy (void) \
{ \
BABL_DESTROY_PRE_HOOK; \
- db_each (each_babl_##type_name##_destroy, NULL); \
- db_destroy (); \
+ babl_db_each (db,each_babl_##type_name##_destroy, NULL); \
+ babl_db_destroy (db); \
BABL_DESTROY_HOOK; \
}
babl = model_new (create_name (name, components, component), id, components, component);
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
return ret;
#include "babl-internal.h"
-static BablSampling db[(HORIZONTAL_MAX-HORIZONTAL_MIN+1)*
- (VERTICAL_MAX-VERTICAL_MIN+1)];
+static BablSampling sampling_db[(HORIZONTAL_MAX-HORIZONTAL_MIN+1)*
+ (VERTICAL_MAX-VERTICAL_MIN+1)];
Babl *
babl_sampling (int horizontal,
vertical<=4 &&
horizontal>=1 &&
horizontal<=4)
- return (Babl*)&db [ (vertical-1) * 4 + (horizontal-1)];
+ return (Babl*)&sampling_db [ (vertical-1) * 4 + (horizontal-1)];
else
babl_log ("babl_samping(%i,%i): arguments out of bounds",
horizontal, vertical);
for (vertical=VERTICAL_MIN; vertical<=VERTICAL_MAX; vertical++)
{
int index= (vertical-VERTICAL_MIN) * VERTICAL_MAX + (horizontal - HORIZONTAL_MIN);
- if (each_fun (BABL (&db[index]), user_data))
+ if (each_fun (BABL (&sampling_db[index]), user_data))
return;
}
}
for (vertical=VERTICAL_MIN; vertical<=VERTICAL_MAX; vertical++)
{
int index= (vertical-VERTICAL_MIN) * VERTICAL_MAX + (horizontal - HORIZONTAL_MIN);
- db[index].instance.class_type = BABL_SAMPLING;
- db[index].instance.id = 0;
- db[index].horizontal = horizontal;
- db[index].vertical = vertical;
- db[index].instance.name = db[index].name;
- db[index].name[0]='0'+horizontal;
- db[index].name[1]=':';
- db[index].name[2]='0'+vertical;
- db[index].name[3]='\0';
+ sampling_db[index].instance.class_type = BABL_SAMPLING;
+ sampling_db[index].instance.id = 0;
+ sampling_db[index].horizontal = horizontal;
+ sampling_db[index].vertical = vertical;
+ sampling_db[index].instance.name = sampling_db[index].name;
+ sampling_db[index].name[0]='0'+horizontal;
+ sampling_db[index].name[1]=':';
+ sampling_db[index].name[2]='0'+vertical;
+ sampling_db[index].name[3]='\0';
}
}
babl = type_new (first_arg, id, bits);
{
- Babl *ret = db_insert (babl);
+ Babl *ret = babl_db_insert (db, babl);
if (ret!=babl)
babl_free (babl);
return ret;
babl_sanity ();
babl_extension_init ();
babl_sanity ();
+ babl_fish_init ();
+ babl_sanity ();
}
}
projects / babl.git / commitdiff